home *** CD-ROM | disk | FTP | other *** search
/ IRIX Base Documentation 2002 November / SGI IRIX Base Documentation 2002 November.iso / usr / share / catman / p_man / cat3 / il_c / ilDisplay.z / ilDisplay
Encoding:
Text File  |  2002-10-03  |  94.8 KB  |  1,980 lines
  1.  
  2.  
  3.  
  4. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  5.  
  6.  
  7.  
  8. NNNNAAAAMMMMEEEE
  9.      iiiillllDDDDiiiissssppppllllaaaayyyy - displays multiple images in an X window
  10.  
  11.  
  12. IIIINNNNHHHHEEEERRRRIIIITTTTSSSS FFFFRRRROOOOMMMM
  13.      This is a base class with no inheritance.
  14.  
  15.  
  16. HHHHEEEEAAAADDDDEEEERRRR FFFFIIIILLLLEEEE
  17.      #include <il/ilCdefs.h>
  18.  
  19.  
  20. CCCCLLLLAAAASSSSSSSS DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
  21.      ilDisplay manages the display of multiple ilImages in an X window. An
  22.      ilImage of any size, color model, or orientation can be displayed. In
  23.      addition, any combination of ilImage can be displayed.  OOOOppppeeeennnnGGGGLLLL is used to
  24.      render the images if supported by the visual associated with the X
  25.      window, otherwise X is used. Multiple images are managed as a stack and
  26.      only the exposed area of each image is painted for optimal performance.
  27.  
  28.      AAAAddddddddiiiinnnngggg IIIImmmmaaaaggggeeeessss
  29.  
  30.      Any iiiillllIIIImmmmaaaaggggeeee can be added to the display by using the aaaaddddddddVVVViiiieeeewwww(((()))) member
  31.      function. ilDisplay creates an iiiillllVVVViiiieeeewwww for the image and puts it into a
  32.      view stack. By default, views are put on top of the stack. However, an
  33.      index can be specified or the mode can be used to control where the view
  34.      is inserted in the stack. Views are displayed based on their stacking
  35.      order. Therefore the view on top of the stack is unobscured and other
  36.      views in the stack may be obscured.  Member functions are provided for
  37.      manipulating the view stack such as push, pop, swap and delete.
  38.  
  39.      An iiiillllVVVViiiieeeewwww pointer is returned by aaaaddddddddVVVViiiieeeewwww() and can be used to manipulate
  40.      the view. For example the view can be repositioned and resized. See
  41.      ilView for more information. The pointer to an ilView can be found in
  42.      several ways using the image or index of the view or by specifying an xy
  43.      location.  When finding a view by xy location, a pointer to the topmost
  44.      view at that location is returned. Note that all views in the view stack
  45.      are deleted when ilDisplay is deleted.
  46.  
  47.      DDDDiiiissssppppllllaaaayyyy OOOOppppeeeerrrraaaattttoooorrrrssss
  48.  
  49.      ilDisplay provides several functions or display operators to manipulate
  50.      views within the display window. Display operators are used to do such
  51.      things as move the view within the display, change the size of the view
  52.      or moved the image within the view. These display operators can be
  53.      applied to one or more views in the view stack.  Typical arguments passed
  54.      to a display operator include an _x_y coordinate pair, a pointer to a _v_i_e_w,
  55.      and a _m_o_d_e.
  56.  
  57.      An _i_l_V_i_e_w* is passed to a display operator to specify which view to
  58.      operate on. If NULL is specified, all views in the stack are operated on.
  59.      However, a view is unaffected if its nop (no-operation) flag is set. The
  60.  
  61.  
  62.  
  63.                                                                         PPPPaaaaggggeeee 1111
  64.  
  65.  
  66.  
  67.  
  68.  
  69.  
  70. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  71.  
  72.  
  73.  
  74.      function sssseeeettttNNNNoooopppp(((()))) can be used to set the nop flag on a single view or all
  75.      views in the stack.
  76.  
  77.      The _m_o_d_e parameter passed to display operators is comprised of one or
  78.      more bit fields. It is passed as an iiiinnnntttt value to allow the bit fields to
  79.      be combined using a bitwise OR. These bit fields are defined as
  80.      enumerated values in iiiillll////iiiillllDDDDiiiissssppppllllaaaayyyyDDDDeeeeffffssss....hhhh. There are several types of modes
  81.      defined, including: ilDefer to defer painting, ilClip to prevent moving
  82.      beyond the edge of the image, ilNoSwap to prevent swapping back/front
  83.      buffers, and operator-specific flags such as ilRightEdge for the wipe
  84.      operator and coordinate interpretation.
  85.  
  86.      The _x, _y coordinates passed to a display operator can be interpreted as
  87.      absolute values, change from current view configuration, or as relative
  88.      to the values initialized by sssseeeettttMMMMoooouuuusssseeee(((()))).  Coordinate interpretation is
  89.      specified by the following flags in _m_o_d_e:
  91.           _i_l_R_e_l_V_a_l    Interpreted relative to the starting _x_y position
  92.                       established with sssseeeettttMMMMoooouuuusssseeee(). The difference between the
  93.                       specified _x_y parameters and the starting _x_y location is
  94.                       used. The starting _x_y location is then updated. Useful
  95.                       for interactive manipulation.
  96.  
  97.           _i_l_O_l_d_R_e_l    Same as _i_l_R_e_l_V_a_l except that the starting _x,_y location
  98.                       is not updated. This is useful when doing several
  99.                       operations based on the same _x,_y coordinates.
  100.  
  101.           _i_l_D_e_l_V_a_l    Interpreted as changes (delta) to the current view
  102.                       configuration.
  103.  
  104.           _i_l_A_b_s_V_a_l    Interpreted as absolute values relative to the ilDisplay
  105.                       origin (upper-left).
  106.  
  107. CCCCLLLLAAAASSSSSSSS MMMMEEEEMMMMBBBBEEEERRRR FFFFUUUUNNNNCCCCTTTTIIIIOOOONNNN SSSSUUUUMMMMMMMMAAAARRRRYYYY
  108.      CCCCoooonnnnssssttttrrrruuuuccccttttoooorrrr
  109.  
  110.           ilDisplay* ilDisplayCreate(Display* display, Window parentWin,
  111.                                      int mode)
  112.           ilDisplay* ilDisplayCreateWindow(Display* display, int width,
  113.                                            int height, int attr,
  114.                                            int minComponentSize,
  115.                                            int maxComponentSize,
  116.                                            int mode, long eventMask)
  117.  
  118.      DDDDeeeessssttttrrrruuuuccccttttoooorrrr
  119.  
  120.           void ilDisplayDelete(ilDisplay* obj)
  121.  
  122.      SSSSyyyynnnncccchhhhrrrroooonnnniiiizzzzaaaattttiiiioooonnnn aaaannnndddd aaaabbbboooorrrrttttiiiinnnngggg
  123.  
  124.  
  126.  
  127.  
  128.                                                                         PPPPaaaaggggeeee 2222
  129.  
  130.  
  131.  
  132.  
  133.  
  134.  
  135. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  136.  
  137.  
  138.  
  139.           void ilDisplaySyncPaint(ilDisplay *obj)
  140.           void ilDisplayFlush(ilDisplay *obj)
  141.           void ilDisplayAbort(ilDisplay *obj)
  142.           void ilDisplayEnableAutoAbort(ilDisplay *obj, int enable)
  143.           int ilDisplayIsAutoAbortEnabled(ilDisplay *obj)
  144.           void ilDisplayEnableQueueing(ilDisplay *obj, int enable)
  145.           int ilDisplayIsQueueingEnabled(ilDisplay *obj)
  146.  
  147.      XXXX WWWWiiiinnnnddddoooowwww aaaacccccccceeeessssssss aaaannnndddd ccccoooonnnnttttrrrroooollll
  148.  
  149.           void ilDisplayUpdateWindow(ilDisplay *obj)
  150.           void ilDisplaySetWindow(ilDisplay *obj, Window win, int mode)
  151.           ilXWindowImg* ilDisplayGetXWindowImg(ilDisplay *obj)
  152.           GLXContext ilDisplayGetGLXContext(ilDisplay *obj)
  153.           Window ilDisplayGetWindow(ilDisplay *obj)
  154.           Display* ilDisplayGetDisplay(ilDisplay *obj)
  155.           Display* ilDisplayGetILDisplay(ilDisplay *obj)
  156.           void ilDisplayCalcWindowSize(ilDisplay *obj, int* width,
  157.                                        int* height)
  158.           void ilDisplayDestroyNotify(ilDisplay *obj)
  159.  
  160.      CCCCoooonnnnttttrrrroooolllllllliiiinnnngggg ddddiiiissssppppllllaaaayyyy mmmmooooddddeeeessss
  161.  
  162.           void ilDisplaySetMode(ilDisplay *obj, int mode)
  163.           void ilDisplayEnableFrontRedraw(ilDisplay *obj, int enable)
  164.           int ilDisplayIsFrontRedrawEnabled(ilDisplay *obj)
  165.  
  166.      RRRReeeennnnddddeeeerrrriiiinnnngggg ccccaaaallllllllbbbbaaaacccckkkkssss
  167.  
  168.           void ilDisplaySetCallback(ilDisplay *obj, ilCallback* prepare,
  169.                                     ilCallback* render, ilCallback* finish)
  170.           void ilDisplayGetCallback(ilDisplay *obj, ilCallback** prepare,
  171.                                     ilCallback** render, ilCallback** finish)
  172.           void ilDisplayEnableCallback(ilDisplay *obj, int enable)
  173.           int ilDisplayIsCallbackEnabled(ilDisplay *obj)
  174.  
  175.      TTTTiiiilllleeee mmmmaaaappppppppiiiinnnngggg
  176.  
  177.           void ilDisplayMapTile(ilDisplay *obj, iflOrientation fromOrientation,
  178.                                 iflTile2Dint* tile, iflOrientation toOrientation(0))
  179.           void ilDisplayMapTileFloat(ilDisplay *obj, iflOrientation fromOrientation,
  180.                                      iflTile2Dfloat* tile, iflOrientation toOrientation(0))
  181.           void ilDisplayMapXY(ilDisplay *obj, iflOrientation fromOrientation,
  182.                               int* x, int* y, iflOrientation toOrientation(0))
  183.           void ilDisplayMapXYFloat(ilDisplay *obj, iflOrientation fromOrientation,
  184.                                    float* x, float* y, iflOrientation toOrientation(0))
  185.  
  186.      VVVViiiissssiiiibbbblllleeee aaaarrrreeeeaaaa ccccoooonnnnttttrrrroooollll
  187.  
  188.           void ilDisplaySetVisibleArea(ilDisplay *obj, int x, int y,
  189.                                        int nx, int ny)
  190.           void ilDisplayGetVisibleArea(ilDisplay *obj, int* x, int* y,
  191.  
  192.  
  193.  
  194.                                                                         PPPPaaaaggggeeee 3333
  195.  
  196.  
  197.  
  198.  
  199.  
  200.  
  201. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  202.  
  203.  
  204.  
  205.                                        int* nx, int* ny)
  206.  
  207.      AAAAttttttttrrrriiiibbbbuuuutttteeee ggggeeeetttt aaaannnndddd sssseeeetttt
  208.  
  209.           void ilDisplayGetPos(ilDisplay *obj, int* x, int* y)
  210.           void ilDisplayGetSize(ilDisplay *obj, int* x, int* y)
  211.           int ilDisplayIsRgb(ilDisplay *obj)
  212.           int ilDisplayIsDoubleBuffer(ilDisplay *obj)
  213.           int ilDisplayIsDefer(ilDisplay *obj, ilView* view)
  214.           void ilDisplaySetDefer(ilDisplay *obj, int def, ilView* view)
  215.           int ilDisplayIsStereo(ilDisplay *obj)
  216.           int ilDisplayGetMargin(ilDisplay *obj)
  217.           void ilDisplaySetMargin(ilDisplay *obj, int margin)
  218.           float ilDisplayGetRoamLimit(ilDisplay *obj)
  219.           void ilDisplaySetRoamLimit(ilDisplay *obj, float maxRoamDel.0)
  220.           void ilDisplayGetRoamRate(ilDisplay *obj, float* x, float* y)
  221.           void ilDisplayGetBackground(ilDisplay *obj, float* red,
  222.                                       float* green, float* blue)
  223.           void ilDisplaySetBackground(ilDisplay *obj, float red,
  224.                                       float green, float blue)
  225.           iflColorModel ilDisplayGetColorModel(ilDisplay *obj)
  226.           void ilDisplaySetColormap(ilDisplay *obj, iflColormap* cmap)
  227.           ilStatus ilDisplayGetColormap(ilDisplay *obj, iflColormap* cmap)
  228.           ilStatus ilDisplayGetStatus(ilDisplay *obj)
  229.           void ilDisplaySetStatus(ilDisplay *obj, ilStatus stat)
  230.           void ilDisplayBackgroundSetDirty(ilDisplay *obj)
  231.  
  232.      VVVViiiieeeewwww mmmmaaaannnniiiippppuuuullllaaaattttiiiioooonnnn
  233.  
  234.           ilView* ilDisplayAddView(ilDisplay *obj, ilImage* img,
  235.                                    int index, int mode)
  236.           ilView* ilDisplayAddViewTop(ilDisplay *obj, ilImage* img,
  237.                                       int mode)
  238.           ilStereoView* ilDisplayAddStereoView(ilDisplay *obj, ilImage* imgL,
  239.                                                ilImage* imgR,
  240.                                                int index, int mode)
  241.           ilStereoView* ilDisplayAddStereoViewTop(ilDisplay *obj,
  242.                                                   ilImage* imgL,
  243.                                                   ilImage* imgR,
  244.                                                   int mode)
  245.           ilStereoView* ilDisplayAddStereoViewZ(ilDisplay *obj,
  246.                                                 ilImage* zImg,
  247.                                                 int zLeft, int zRight,
  248.                                                 int index, int mode)
  249.           ilStereoView* ilDisplayAddStereoViewZTop(ilDisplay *obj,
  250.                                                    ilImage* zImg,
  251.                                                    int zLeft,
  252.                                                    int zRight,
  253.                                                    int mode)
  254.           ilView* ilDisplayAddViewPtr(ilDisplay *obj, ilView* view,
  255.                                       int index, int mode)
  256.           void ilDisplayDeleteView(ilDisplay *obj, ilView* view)
  257.  
  258.  
  259.  
  260.                                                                         PPPPaaaaggggeeee 4444
  261.  
  262.  
  263.  
  264.  
  265.  
  266.  
  267. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  268.  
  269.  
  270.  
  271.           void ilDisplayDeleteViewIdx(ilDisplay *obj, int index)
  272.           void ilDisplayAddViewChangeCallback(ilDisplay *obj, ilCallback* cb,
  273.                                               int autoDelete)
  274.           ilStatus ilDisplayRemoveViewChangeCallback(ilDisplay *obj,
  275.                                                      ilCallback* cb)
  276.           void ilDisplayPush(ilDisplay *obj, ilView* view, int count)
  277.           void ilDisplayPop(ilDisplay *obj, ilView* view, int count)
  278.           void ilDisplaySwap(ilDisplay *obj, ilView* view1, ilView* view2)
  279.           ilView* ilDisplayFindView(ilDisplay *obj, int x, int y,
  280.                                     int mode)
  281.           ilView* ilDisplayGetViewIdx(ilDisplay *obj, int index)
  282.           ilView* ilDisplayGetViewImg(ilDisplay *obj, ilImage* img)
  283.           int ilDisplayGetViewIndex(ilDisplay *obj, ilView* view)
  284.           int ilDisplayGetViewIndexImg(ilDisplay *obj, ilImage* img)
  285.           int ilDisplayGetNumViews(ilDisplay *obj)
  286.           ilView* ilDisplayGetLoc(ilDisplay *obj, float x, float y,
  287.                                   float* ix, float* iy, int mode)
  288.           ilView* ilDisplaySetLoc(ilDisplay *obj, float ix, float iy,
  289.                                   float x, float y, int mode)
  290.           ilView* ilDisplayGetPixel(ilDisplay *obj, int x, int y,
  291.                                     iflPixel* pix)
  292.           ilView* ilDisplaySetPixel(ilDisplay *obj, int x, int y,
  293.                                     iflPixel* pix)
  294.           int ilDisplayIsNop(ilDisplay *obj, ilView* view)
  295.           void ilDisplaySetNop(ilDisplay *obj, int noOp, ilView* view)
  296.           void ilDisplaySelect(ilDisplay *obj, ilView* view)
  297.           void ilDisplayUnselect(ilDisplay *obj, ilView* view)
  298.           int ilDisplayIsSelected(ilDisplay *obj, ilView* view)
  299.           void ilDisplaySetBorders(ilDisplay *obj, int enable, int mode)
  300.           void ilDisplaySetBorderStyle(ilDisplay *obj, int style)
  301.           void ilDisplaySetBorderColor(ilDisplay *obj, float red,
  302.                                        float green, float blue)
  303.           void ilDisplaySetBorderWidth(ilDisplay *obj, int width)
  304.  
  305.      DDDDiiiissssppppllllaaaayyyy ooooppppeeeerrrraaaattttoooorrrr ssssuuuuppppppppoooorrrrtttt
  306.  
  307.           void ilDisplaySetMouse(ilDisplay *obj, int x, int y, int mode)
  308.           void ilDisplayGetMouse(ilDisplay *obj, int* x, int* y)
  309.           void ilDisplayGetMouseOrientation(ilDisplay *obj, int* x,
  310.                                             int* y, iflOrientation orientation)
  311.           int ilDisplayFindEdge(ilDisplay *obj, int x, int y, int margin-1,
  312.                                 int mode)
  313.  
  314.      DDDDiiiissssppppllllaaaayyyy ooooppppeeeerrrraaaattttoooorrrrssss
  315.  
  316.           void ilDisplayDisplay(ilDisplay *obj, ilView* view, int vMode,
  317.                                 int iMode)
  318.           void ilDisplayRedrawArea(ilDisplay *obj, int x, int y,
  319.                                    int nx, int ny, iflOrientation orientation,
  320.                                    int mode)
  321.           void ilDisplayRedraw(ilDisplay *obj, int mode)
  322.           void ilDisplayPaintArea(ilDisplay *obj, int x, int y,
  323.  
  324.  
  325.  
  326.                                                                         PPPPaaaaggggeeee 5555
  327.  
  328.  
  329.  
  330.  
  331.  
  332.  
  333. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  334.  
  335.  
  336.  
  337.                                   int nx, int ny, iflOrientation orientation,
  338.                                   ilView* view, int mode)
  339.           void ilDisplayPaint(ilDisplay *obj, ilView* view, int mode)
  340.           void ilDisplayQPaintArea(ilDisplay *obj, ilMpNode* parent,
  341.                                    int x, int y, int nx, int ny,
  342.                                    iflOrientation orientation,
  343.                                    ilView* view, int mode, ilMpManager** pMgr)
  344.           void ilDisplayQPaint(ilDisplay *obj, ilMpNode* parent,
  345.                                ilView* view, int mode, ilMpManager** pMgr)
  346.           void ilDisplayMoveView(ilDisplay *obj, int x, int y, ilView* view,
  347.                                  int mode)
  348.           void ilDisplayMoveImg(ilDisplay *obj, float x, float y,
  349.                                 ilView* view, int mode)
  350.           void ilDisplayMoveImgIdx(ilDisplay *obj, float x, float y,
  351.                                 ilView* view, int idx, int mode)
  352.           void ilDisplayWipe(ilDisplay *obj, int x, int y, ilView* view,
  353.                              int mode)
  354.           void ilDisplayWipeSplit(ilDisplay *obj, int x, int y,
  355.                                   int mode)
  356.           void ilDisplayWipeSize(ilDisplay *obj, int x, int y, ilView* view,
  357.                                  int mode)
  358.           void ilDisplaySplit(ilDisplay *obj, int mode)
  359.           void ilDisplayAlignImg(ilDisplay *obj, ilView* view, int mode)
  360.           void ilDisplayAlignView(ilDisplay *obj, ilView* view,
  361.                                   int mode, ilView* rView)
  362.           void ilDisplayUpdate(ilDisplay *obj, int x, int y, int nx,
  363.                                int ny, float imgX, float imgY,
  364.                                ilView* view, int mode)
  365.           ilStatus ilDisplaySave(ilDisplay *obj, ilImage* img, int x,
  366.                                  int y, int mode)
  367.  
  368.  
  369.  
  370. FFFFUUUUNNNNCCCCTTTTIIIIOOOONNNN DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNNSSSS
  371.      iiiillllDDDDiiiissssppppllllaaaayyyy(((())))
  372.  
  373.           ilDisplay* ilDisplayCreate(Display* display, Window parentWin,
  374.                                      int mode)
  375.           ilDisplay* ilDisplayCreateWindow(Display* display, int width,
  376.                                            int height, int attr,
  377.                                            int minComponentSize,
  378.                                            int maxComponentSize,
  379.                                            int mode, long eventMask)
  380.  
  381.  
  382.           Both versions of the constructor create an ilDisplay object to
  383.           manage views of images within an X window. The _m_o_d_e parameter is
  384.           used to specify the view mode when adding ilViews objects with
  385.           aaaaddddddddVVVViiiieeeewwww().  For example, iiiillllDDDDeeeeffffeeeerrrr could be used to add views without
  386.           painting each one as it is added to the display.
  387.  
  388.  
  389.  
  390.  
  391.  
  392.                                                                         PPPPaaaaggggeeee 6666
  393.  
  394.  
  395.  
  396.  
  397.  
  398.  
  399. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  400.  
  401.  
  402.  
  403.           Since OpenGL and X rendering can be mixed, the render mode is
  404.           determined automatically. If the X visual associated with the window
  405.           supports OpenGL rendering then OpenGL rendering will be used.
  406.           Otherwise X rendering will be used. Note that hardware acceleration
  407.           only occurs during OpenGL rendering.
  408.  
  409.           The second version of the constructor creates an X window as
  410.           specified by the various parameters. The created window will be
  411.           _w_i_d_t_h wide, _h_e_i_g_h_t high with the attributes specified by _a_t_t_r,
  412.           _m_i_n_C_o_m_p_o_n_e_n_t_S_i_z_e and _m_a_x_C_o_m_p_o_n_e_n_t_S_i_z_e for the visual class.  See
  413.           iiiillllXXXXWWWWiiiinnnnddddoooowwwwIIIImmmmgggg for more information. In addition, it will select the X
  414.           events passed in _e_v_e_n_t_M_a_s_k.
  415.  
  416.           A background view is created and is painted by default. However, if
  417.           ilDefer is passed in _m_o_d_e, painting will be deferred.  Also, an RGB
  418.           colormap will be loaded if needed. However, an application can load
  419.           a colormap or use the default colormap by passing ilDefaultCmap in
  420.           _m_o_d_e. This will cause ilDisplay to not load a colormap.
  421.  
  422.      iiiillllDDDDiiiissssppppllllaaaayyyyDDDDeeeelllleeeetttteeee(((())))
  423.  
  424.           void ilDisplayDelete(ilDisplay* obj)
  425.  
  426.  
  427.           Removes and deletes all of the allocated pointers and items used by
  428.           the ilDisplay. Also deletes all view in the view stack.
  429.  
  430.      aaaabbbboooorrrrtttt(((())))
  431.  
  432.           void ilDisplayAbort(ilDisplay *obj)
  433.  
  434.  
  435.           This method aborts any queued paint requests.  It works in
  436.           conjunction with the eeeennnnaaaabbbblllleeeeQQQQuuuueeeeuuuueeeeiiiinnnngggg() method.
  437.  
  438.      aaaaddddddddSSSStttteeeerrrreeeeooooVVVViiiieeeewwww(((())))
  439.  
  440.           ilStereoView* ilDisplayAddStereoView(ilDisplay *obj, ilImage* imgL,
  441.                                                ilImage* imgR,
  442.                                                int index, int mode)
  443.           ilStereoView* ilDisplayAddStereoViewTop(ilDisplay *obj,
  444.                                                   ilImage* imgL,
  445.                                                   ilImage* imgR,
  446.                                                   int mode)
  447.           ilStereoView* ilDisplayAddStereoViewZTop(ilDisplay *obj,
  448.                                                    ilImage* zImg,
  449.                                                    int zLeft,
  450.                                                    int zRight,
  451.                                                    int mode)
  452.           ilStereoView* ilDisplayAddStereoViewZ(ilDisplay *obj,
  453.                                                 ilImage* zImg,
  454.                                                 int zLeft, int zRight,
  455.  
  456.  
  457.  
  458.                                                                         PPPPaaaaggggeeee 7777
  459.  
  460.  
  461.  
  462.  
  463.  
  464.  
  465. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  466.  
  467.  
  468.  
  469.                                                 int index, int mode)
  470.  
  471.  
  472.           These methods allow a pair of ilImages to be specified as the left
  473.           image and the right image of a stereo pair. In addition, a stereo
  474.           pair may be stored in a single image using the Z dimension. In this
  475.           case, the image is specified as _z_I_m_g. The Z index to the left image
  476.           is specified as _z_L_e_f_t and the Z index to the right image is
  477.           specified as _z_R_i_g_h_t. By default, zLeft is 0 and zRight is 1. The
  478.           advantage of this approach, is that a single IL chain can be used to
  479.           process the stereo pair, rather than having a chain to process each
  480.           image.
  481.  
  482.      aaaaddddddddVVVViiiieeeewwww(((())))
  483.  
  484.           ilView* ilDisplayAddView(ilDisplay *obj, ilImage* img,
  485.                                    int index, int mode)
  486.           ilView* ilDisplayAddViewTop(ilDisplay *obj, ilImage* img,
  487.                                       int mode)
  488.           ilView* ilDisplayAddViewPtr(ilDisplay *obj, ilView* view,
  489.                                       int index, int mode)
  490.  
  491.  
  492.           Creates an ilView for the image specified by, _i_m_g, and adds it to
  493.           the view stack at the index specified by, _i_d_x. By default, the view
  494.           is added to the top of the stack. If _i_d_x equals _i_l_L_a_s_t, the view is
  495.           added to the bottom of the stack. The mode parameter controls the
  496.           creation and position of the ilView. By default, the ilView is the
  497.           size of the image. However, if _i_l_C_l_i_p is passed in _m_o_d_e, then the
  498.           ilView will be clipped to the size of the display window. By
  499.           default, the view is painted after it is added to the stack.
  500.           However, if _i_l_D_e_f_e_r is passed, then painting is deferred. Also, an
  501.           alignment mode such as _i_l_C_e_n_t_e_r may be passed to control how the
  502.           image is aligned within the view and how the view is aligned within
  503.           the display window. Center alignment is used by default.
  504.  
  505.           Several versions of aaaaddddddddVVVViiiieeeewwww() are provided for convenience. The
  506.           version that takes an index, allows the position in the view stack
  507.           to be specified. Often however, putting the image on top of the
  508.           stack is acceptable and only the image and mode need to be
  509.           specified. Therefore, a second version is provided that only
  510.           requires an image and a mode to be specified.  Since this version
  511.           puts the view on top of the view stack, its name ends with "Top".
  512.  
  513.  
  514.  
  515.  
  516.  
  517.  
  518.  
  519.  
  520.  
  521.  
  522.  
  523.  
  524.                                                                         PPPPaaaaggggeeee 8888
  525.  
  526.  
  527.  
  528.  
  529.  
  530.  
  531. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  532.  
  533.  
  534.  
  535.      aaaaddddddddVVVViiiieeeewwwwCCCChhhhaaaannnnggggeeeeCCCCaaaallllllllbbbbaaaacccckkkk(((())))
  536.  
  537.           void ilDisplayAddViewChangeCallback(ilDisplay *obj, ilCallback* cb,
  538.                                               int autoDelete)
  539.  
  540.  
  541.           This method adds a callback that will be triggered whenever a view
  542.           is added to or deleted from this object.  Either
  543.           ilViewChangeMethodCB or ilViewChangeFunctionCB can used with this
  544.           method. The callback method or function will have the prototype:
  545.  
  546.               func(UserArgType userArg, ilViewChangeArg* callerArg)
  547.  
  548.  
  549.           To define and use a view change callback to a member function you
  550.           might do something like:
  551.  
  552.               ...
  553.               ilStatus Bar::change(Foo*, ilViewChangeArg*) { ... }
  554.               ...
  555.               typedef ilViewChangeMethodCB<Bar,Foo*> ViewChangeCallback;
  556.  
  557.               Bar bar;
  558.               Foo foo;
  559.               ViewChangeCallback changeCb(&bar, Bar::change, &foo);
  560.  
  561.               disp->addViewChangeCallback(&changeCb);
  562.  
  563.  
  564.           The passed ilViewChangeArg contains two members:
  565.  
  566.           _r_e_a_s_o_n    The reason for this callback: either _i_l_V_i_e_w_A_d_d_e_d or
  567.                     _i_l_V_i_e_w_D_e_l_e_t_e_d.
  568.  
  569.           _v_i_e_w      The view being added or the view about to be deleted.
  570.  
  571.      aaaalllliiiiggggnnnnIIIImmmmgggg(((())))
  572.  
  573.           void ilDisplayAlignImg(ilDisplay *obj, ilView* view, int mode)
  574.  
  575.  
  576.           Aligns the image in the specified view based on _m_o_d_e. If NULL is
  577.           passed, then the image in all views in the view stack are aligned
  578.           (expect those with nop flag set). For example, if ilCenter is
  579.           specified, the images are centered within the view.  Similarly, if
  580.           ilBottomLeft is specified, the lower left corner of the image is
  581.           aligned to the lower left corner of the view. See _i_l/_i_l_D_i_s_p_l_a_y_D_e_f._h
  582.           for a complete list of modes.
  583.  
  584.  
  585.  
  586.  
  587.  
  588.  
  589.  
  590.                                                                         PPPPaaaaggggeeee 9999
  591.  
  592.  
  593.  
  594.  
  595.  
  596.  
  597. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  598.  
  599.  
  600.  
  601.      aaaalllliiiiggggnnnnVVVViiiieeeewwww(((())))
  602.  
  603.           void ilDisplayAlignView(ilDisplay *obj, ilView* view,
  604.                                   int mode, ilView* rView)
  605.  
  606.  
  607.           Aligns the specified view to the reference view specified in _r_V_i_e_w.
  608.           If NULL is passed then all views are aligned (except those with nop
  609.           flag set). The two views are aligned based on bit flags passed in
  610.           _m_o_d_e. For example, it ilCenter is specified, the center of the view
  611.           is aligned to the center of the reference view. Similarly, if
  612.           ilTopRight is specified, the upper right corner of the view is
  613.           aligned to the upper right corner of the reference view. If NULL is
  614.           passed in rView, the background view in ilDisplay is used. See
  615.           _i_l/_i_l_D_i_s_p_l_a_y_D_e_f._h for a complete list of modes.
  616.  
  617.      ccccaaaallllccccWWWWiiiinnnnddddoooowwwwSSSSiiiizzzzeeee(((())))
  618.  
  619.           void ilDisplayCalcWindowSize(ilDisplay *obj, int* width,
  620.                                        int* height)
  621.  
  622.  
  623.           This method computes a window size that won't clip any of the images
  624.           in the current set of views, this size is clipped to the size of the
  625.           screen.
  626.  
  627.      ddddeeeelllleeeetttteeeeVVVViiiieeeewwww(((())))
  628.  
  629.           void ilDisplayDeleteView(ilDisplay *obj, ilView* view)
  630.           void ilDisplayDeleteViewIdx(ilDisplay *obj, int index)
  631.  
  632.  
  633.           Removes the specified view from the view stack and deletes the
  634.           ilView.  The display is then repainted.
  635.  
  636.      ddddeeeessssttttrrrrooooyyyyNNNNoooottttiiiiffffyyyy(((())))
  637.  
  638.           void ilDisplayDestroyNotify(ilDisplay *obj)
  639.  
  640.  
  641.           This method is intended to be called when the X window used by this
  642.           object has been destroyed, typically when a DestroyNotify X event is
  643.           handled.
  644.  
  645.      ddddiiiissssppppllllaaaayyyy(((())))
  646.  
  647.           void ilDisplayDisplay(ilDisplay *obj, ilView* view, int vMode,
  648.                                 int iMode)
  649.  
  650.  
  651.  
  652.  
  653.  
  654.  
  655.  
  656.                                                                        PPPPaaaaggggeeee 11110000
  657.  
  658.  
  659.  
  660.  
  661.  
  662.  
  663. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  664.  
  665.  
  666.  
  667.           This function resizes, aligns, and paints the specified view. If
  668.           NULL is passed, then all views are operated on (except those with
  669.           nop flag set). If ilDefer is specified, then painting is deferred.
  670.           The view is resized to the size of the image. However, if ilClip is
  671.           specified, the view is clipped to the size of the display. The view
  672.           is aligned as specified in _v_M_o_d_e, and the image mapped to the view
  673.           is aligned as specified in _i_M_o_d_e.
  674.  
  675.      eeeennnnaaaabbbblllleeeeAAAAuuuuttttooooAAAAbbbboooorrrrtttt(((())))
  676.  
  677.           void ilDisplayEnableAutoAbort(ilDisplay *obj, int enable)
  678.  
  679.  
  680.           This method enables automatic aborting of queued requests; when this
  681.           mode is turned on any new painting operations will automatically
  682.           cancel paint operations in progress. This mode only makes sense if
  683.           queueing is enabled (see eeeennnnaaaabbbblllleeeeQQQQuuuueeeeuuuueeeeiiiinnnngggg()).
  684.  
  685.      eeeennnnaaaabbbblllleeeeCCCCaaaallllllllbbbbaaaacccckkkk(((())))
  686.  
  687.           void ilDisplayEnableCallback(ilDisplay *obj, int enable)
  688.  
  689.  
  690.           This member function enables (_T_r_u_e) or disables (_F_a_l_s_e) the post-
  691.           render callback setup with sssseeeettttCCCCaaaallllllllbbbbaaaacccckkkk(). Note that the callback
  692.           must be set and enabled to be operable.
  693.  
  694.      eeeennnnaaaabbbblllleeeeFFFFrrrroooonnnnttttRRRReeeeddddrrrraaaawwww(((())))
  695.  
  696.           void ilDisplayEnableFrontRedraw(ilDisplay *obj, int enable)
  697.  
  698.  
  699.           This member function enables or disables drawing to the front buffer
  700.           when iiiillllDDDDiiiissssppppllllaaaayyyyRRRReeeeddddrrrraaaawwww() is called. This allows better visual feedback
  701.           when in double buffer mode.  If _T_r_u_e is passed then front redraw is
  702.           enabled. Otherwise, it is disabled.
  703.  
  704.      eeeennnnaaaabbbblllleeeeQQQQuuuueeeeuuuueeeeiiiinnnngggg(((())))
  705.  
  706.           void ilDisplayEnableQueueing(ilDisplay *obj, int enable)
  707.  
  708.  
  709.           This method controls whether queued painting is actually allowed,
  710.           the default mode is that queued painting will not be done.  When the
  711.           mode is enabled, call to various display operation (like mmmmoooovvvveeeeIIIImmmmgggg())
  712.           will return before the rendering is completed.  When another
  713.           operations is requested it will be started before waiting for the
  714.           last operation to complete to allow overlapped prefetching of data.
  715.           This mode is currently only supported on MP machines.
  716.  
  717.  
  718.  
  719.  
  720.  
  721.  
  722.                                                                        PPPPaaaaggggeeee 11111111
  723.  
  724.  
  725.  
  726.  
  727.  
  728.  
  729. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  730.  
  731.  
  732.  
  733.           Completion of the queued operation can be ensured by calling the
  734.           ssssyyyynnnnccccPPPPaaaaiiiinnnntttt() method.  Queued operations can be aborted with the
  735.           aaaabbbboooorrrrtttt() method.
  736.  
  737.      ffffiiiinnnnddddEEEEddddggggeeee(((())))
  738.  
  739.           int ilDisplayFindEdge(ilDisplay *obj, int x, int y, int margin-1,
  740.                                 int mode)
  741.  
  742.  
  743.           Returns the edge or edges within _m_a_r_g_i_n pixels of _x and _y.  The view
  744.           stack is searched from top to bottom so that edges of the top view
  745.           are returned. However, ilNoEdge is returned if no edge is found and
  746.           ilNoView is returned if there is no view at the location specified
  747.           by _x and _y.
  748.  
  749.      ffffiiiinnnnddddVVVViiiieeeewwww(((())))
  750.  
  751.           ilView* ilDisplayFindView(ilDisplay *obj, int x, int y,
  752.                                     int mode)
  753.  
  754.  
  755.           Returns a pointer to the top-most ilView found at location (_x,_y)
  756.           within the display. If there is no view at (x,y), NULL is returned.
  757.           If ilDspCoord is passed in mode (default), then the (x,y)
  758.           coordinates are interpreted relative to the display window. If
  759.           ilScrCoord is passed in mode, then the (x,y) coordinates are
  760.           interpreted relative to the screen.
  761.  
  762.      fffflllluuuusssshhhh(((())))
  763.  
  764.           void ilDisplayFlush(ilDisplay *obj)
  765.  
  766.  
  767.           Flushes graphics commands that may be buffered. Usually, it is not
  768.           necessary to call flush in interactive applications.
  769.  
  770.      ggggeeeettttBBBBaaaacccckkkkggggrrrroooouuuunnnndddd(((())))
  771.  
  772.           void ilDisplayGetBackground(ilDisplay *obj, float* red,
  773.                                       float* green, float* blue)
  774.  
  775.  
  776.           Returns the current background color in _r_e_d, _g_r_e_e_n and _b_l_u_e.  See
  777.           ilDisplaySetBackground()
  778.  
  779.      ggggeeeettttCCCCaaaallllllllbbbbaaaacccckkkk(((())))
  780.  
  781.           void ilDisplayGetCallback(ilDisplay *obj, ilCallback** prepare,
  782.                                     ilCallback** render, ilCallback** finish)
  783.  
  784.  
  785.  
  786.  
  787.  
  788.                                                                        PPPPaaaaggggeeee 11112222
  789.  
  790.  
  791.  
  792.  
  793.  
  794.  
  795. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  796.  
  797.  
  798.  
  799.           Returns pointers to the _p_r_e_p_a_r_e callback, _r_e_n_d_e_r callback and _f_i_n_i_s_h
  800.           callback in the repective parameters. These callbacks were
  801.           previousely set with sssseeeettttCCCCaaaallllllllbbbbaaaacccckkkk(). See iiiillllVVVViiiieeeewwww and iiiillllVVVViiiieeeewwwwCCCCaaaallllllllbbbbaaaacccckkkk
  802.           for more information.
  803.  
  804.      ggggeeeettttCCCCoooolllloooorrrrMMMMooooddddeeeellll(((())))
  805.  
  806.           iflColorModel ilDisplayGetColorModel(ilDisplay *obj)
  807.  
  808.  
  809.           Returns the color model of the display image.
  810.  
  811.      ggggeeeettttCCCCoooolllloooorrrrmmmmaaaapppp(((())))
  812.  
  813.           ilStatus ilDisplayGetColormap(ilDisplay *obj, iflColormap* cmap)
  814.  
  815.  
  816.           Returns the current colormap in _l_u_t. The colormap is used by
  817.           iiiillllXXXXDDDDiiiissssppppllllaaaayyyyIIIImmmmgggg or iiiillllGGGGLLLLDDDDiiiissssppppllllaaaayyyyIIIImmmmgggg, depending on the render mode.
  818.  
  819.      ggggeeeettttDDDDiiiissssppppllllaaaayyyy(((())))
  820.  
  821.           Display* ilDisplayGetDisplay(ilDisplay *obj)
  822.  
  823.  
  824.           Returns the X Display currently being used.
  825.  
  826.      ggggeeeettttGGGGLLLLXXXXCCCCoooonnnntttteeeexxxxtttt(((())))
  827.  
  828.           GLXContext ilDisplayGetGLXContext(ilDisplay *obj)
  829.  
  830.  
  831.           This method returns the OpenGL rendering context used by IL.  This
  832.           can be used to create display lists in a user context that can be
  833.           shared with the IL context, and thus used in the rendering
  834.           callbacks.  To do this the user context must be created specifying
  835.           the IL context as the _s_h_a_r_e_L_i_s_t parameter of ggggllllXXXXCCCCrrrreeeeaaaatttteeeeCCCCoooonnnntttteeeexxxxtttt().
  836.  
  837.      ggggeeeettttIIIILLLLDDDDiiiissssppppllllaaaayyyy(((())))
  838.  
  839.           Display* ilDisplayGetILDisplay(ilDisplay *obj)
  840.  
  841.  
  842.           This method returns the internal Display* that IL uses.  This is not
  843.           intended for use outside of IL.
  844.  
  845.      ggggeeeettttLLLLoooocccc(((())))
  846.  
  847.           ilView* ilDisplayGetLoc(ilDisplay *obj, float x, float y,
  848.                                   float* ix, float* iy, int mode)
  849.  
  850.  
  851.  
  852.  
  853.  
  854.                                                                        PPPPaaaaggggeeee 11113333
  855.  
  856.  
  857.  
  858.  
  859.  
  860.  
  861. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  862.  
  863.  
  864.  
  865.           This function finds the view at (_x, _y) and returns the corresponding
  866.           location in the image in _i_x and _i_y. If _i_l_L_o_c_I_n is passed in _m_o_d_e,
  867.           the location is returned in the input space of the image.  If
  868.           _i_l_L_o_c_O_u_t is passed in _m_o_d_e, the location is returned in the output
  869.           space of the image. For example, if an ilRotZoomIng is mapped to the
  870.           view and _i_l_L_o_c_I_n is specified, _i_x and _i_y will correspond to the
  871.           location in the unzoomed image. However, if _i_l_L_o_c_O_u_t is specified,
  872.           _i_x and _i_y correspond to the location in the zoomed image.
  873.  
  874.      ggggeeeettttMMMMaaaarrrrggggiiiinnnn(((())))
  875.  
  876.           int ilDisplayGetMargin(ilDisplay *obj)
  877.  
  878.  
  879.           Returns the current margin in pixels that is used for ffffiiiinnnnddddEEEEddddggggeeee().
  880.  
  881.      ggggeeeettttMMMMoooouuuusssseeee(((())))
  882.  
  883.           void ilDisplayGetMouse(ilDisplay *obj, int* x, int* y)
  884.           void ilDisplayGetMouseOrientation(ilDisplay *obj, int* x,
  885.                                             int* y, iflOrientation orientation)
  886.  
  887.  
  888.           Returns the current XY location of the mouse. The mouse position is
  889.           set with sssseeeettttMMMMoooouuuusssseeee(((()))) and is updated by display operators that are
  890.           passed _i_l_R_e_l_V_a_l parameter mode. The values _x and _y, are returned for
  891.           the specified orientation. The first version, uses the current _e_v_e_n_t
  892.           orientation. This method is useful for some interactive
  893.           applications.
  894.  
  895.      ggggeeeettttNNNNuuuummmmVVVViiiieeeewwwwssss(((())))
  896.  
  897.           int ilDisplayGetNumViews(ilDisplay *obj)
  898.  
  899.  
  900.           Returns the number of ilViews in the view stack. The background view
  901.           can not be accessed and is not included in the count.
  902.  
  903.      ggggeeeettttPPPPiiiixxxxeeeellll(((())))
  904.  
  905.           ilView* ilDisplayGetPixel(ilDisplay *obj, int x, int y,
  906.                                     iflPixel* pix)
  907.  
  908.  
  909.           Copies into _p_i_x the pixel value at coordinates (_x, _y), in ilDisplay
  910.           coordinates. The pixel value is obtained from _v_i_e_w.  If _v_i_e_w is
  911.           NULL, then the view at _x,_y is found first.
  912.  
  913.      ggggeeeettttPPPPoooossss(((())))
  914.  
  915.  
  916.  
  917.  
  918.  
  919.  
  920.                                                                        PPPPaaaaggggeeee 11114444
  921.  
  922.  
  923.  
  924.  
  925.  
  926.  
  927. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  928.  
  929.  
  930.  
  931.           void ilDisplayGetPos(ilDisplay *obj, int* x, int* y)
  932.  
  933.  
  934.           Returns the current position of the ilDisplayImg within the display
  935.           window. ilDisplay creates a ilDisplayImg (X or GL) to perform the
  936.           actual rendering to the frame buffer. It is maintained at position
  937.           0, 0 within the display window.
  938.  
  939.      ggggeeeettttRRRRooooaaaammmmLLLLiiiimmmmiiiitttt(((())))
  940.  
  941.           float ilDisplayGetRoamLimit(ilDisplay *obj)
  942.  
  943.  
  944.           Returns the roam limit previously set with iiiillllDDDDiiiissssppppllllaaaayyyySSSSeeeettttRRRRooooaaaammmmLLLLiiiimmmmiiiitttt().
  945.           The roam limit causes image movement to be limited in order to
  946.           facilitate smooth roaming with iiiillllDDDDiiiissssppppllllaaaayyyyMMMMoooovvvveeeeIIIImmmmgggg() or
  947.           iiiillllDDDDiiiissssppppllllaaaayyyyMMMMoooovvvveeeeIIIImmmmggggIIIIddddxxxx(). The roam limit is used to calculate the
  948.           maximum roam rate in x and y for a given direction.
  949.  
  950.      ggggeeeettttRRRRooooaaaammmmRRRRaaaatttteeee(((())))
  951.  
  952.           void ilDisplayGetRoamRate(ilDisplay *obj, float* x, float* y)
  953.  
  954.  
  955.           Returns the horizontal and vertical roam rate in _x and _y.  If a roam
  956.           limit has been set with iiiillllDDDDiiiissssppppllllaaaayyyySSSSeeeettttRRRRooooaaaammmmLLLLiiiimmmmiiiitttt(), then image movement
  957.           may be clipped when using iiiillllDDDDiiiissssppppllllaaaayyyyMMMMoooovvvveeeeIIIImmmmgggg() or
  958.           iiiillllDDDDiiiissssppppllllaaaayyyyMMMMoooovvvveeeeIIIImmmmggggIIIIddddxxxx().  The returned values give the number of
  959.           pixels the image was moved in the x and y directions. The roam rate
  960.           is updated each time iiiillllDDDDiiiissssppppllllaaaayyyyMMMMoooovvvveeeeIIIImmmmgggg() or iiiillllDDDDiiiissssppppllllaaaayyyyMMMMoooovvvveeeeIIIImmmmggggIIIIddddxxxx() is
  961.           called.
  962.  
  963.      ggggeeeettttSSSSiiiizzzzeeee(((())))
  964.  
  965.           void ilDisplayGetSize(ilDisplay *obj, int* x, int* y)
  966.  
  967.  
  968.           Returns the size of the ilDisplayImg into _x and _y.
  969.  
  970.      ggggeeeettttSSSSttttaaaattttuuuussss(((())))
  971.  
  972.           ilStatus ilDisplayGetStatus(ilDisplay *obj)
  973.  
  974.  
  975.           Returns the current status. See /_u_s_r/_i_n_c_l_u_d_e/_i_l/_i_l_E_r_r_o_r._h for a list
  976.           of error codes.
  977.  
  978.      ggggeeeettttVVVViiiieeeewwww(((())))
  979.  
  980.           ilView* ilDisplayGetViewImg(ilDisplay *obj, ilImage* img)
  981.           ilView* ilDisplayGetViewIdx(ilDisplay *obj, int index)
  982.  
  983.  
  984.  
  985.  
  986.                                                                        PPPPaaaaggggeeee 11115555
  987.  
  988.  
  989.  
  990.  
  991.  
  992.  
  993. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  994.  
  995.  
  996.  
  997.           Returns a pointer to the ilView that corresponds to _i_d_x in the view
  998.           stack, or the bottom-most ilView containing _i_m_g. If no ilView is
  999.           found, NULL is returned. Note that the back view can not be
  1000.           accessed.
  1001.  
  1002.      ggggeeeettttVVVViiiieeeewwwwIIIInnnnddddeeeexxxx(((())))
  1003.  
  1004.           int ilDisplayGetViewIndexImg(ilDisplay *obj, ilImage* img)
  1005.           int ilDisplayGetViewIndex(ilDisplay *obj, ilView* view)
  1006.  
  1007.  
  1008.           Returns the index into the display's ilView corresponding to _v_i_e_w
  1009.           or, the index of the bottom-most ilView containing _i_m_g.  If _v_i_e_w or
  1010.           _i_m_g is not in the list, ilNoListIndex is returned.
  1011.  
  1012.      ggggeeeettttVVVViiiissssiiiibbbblllleeeeAAAArrrreeeeaaaa(((())))
  1013.  
  1014.           void ilDisplayGetVisibleArea(ilDisplay *obj, int* x, int* y,
  1015.                                        int* nx, int* ny)
  1016.  
  1017.  
  1018.           Returns the current visible area. If the area is valid, then
  1019.           painting is limited to this area. This feature is useful for
  1020.           scrolled windows.  See iiiillllDDDDiiiissssppppllllaaaayyyySSSSeeeettttVVVViiiissssiiiibbbblllleeeeAAAArrrreeeeaaaa() for more
  1021.           information.
  1022.  
  1023.      ggggeeeettttWWWWiiiinnnnddddoooowwww(((())))
  1024.  
  1025.           Window ilDisplayGetWindow(ilDisplay *obj)
  1026.  
  1027.  
  1028.           Returns the X Window currently being used.
  1029.  
  1030.      ggggeeeettttXXXXWWWWiiiinnnnddddoooowwwwIIIImmmmgggg(((())))
  1031.  
  1032.           ilXWindowImg* ilDisplayGetXWindowImg(ilDisplay *obj)
  1033.  
  1034.  
  1035.           This method returns the ilXWindowImg created by this object.  It is
  1036.           used for all rendering operations.
  1037.  
  1038.      iiiissssAAAAuuuuttttooooAAAAbbbboooorrrrttttEEEEnnnnaaaabbbblllleeeedddd(((())))
  1039.  
  1040.           int ilDisplayIsAutoAbortEnabled(ilDisplay *obj)
  1041.  
  1042.  
  1043.           Returns TRUE if auto-abort is enabled, FALSE otherwise.  See
  1044.           eeeennnnaaaabbbblllleeeeAAAAuuuuttttooooAAAAbbbboooorrrrtttt().
  1045.  
  1046.      iiiissssCCCCaaaallllllllbbbbaaaacccckkkkEEEEnnnnaaaabbbblllleeeedddd(((())))
  1047.  
  1048.  
  1049.  
  1050.  
  1051.  
  1052.                                                                        PPPPaaaaggggeeee 11116666
  1053.  
  1054.  
  1055.  
  1056.  
  1057.  
  1058.  
  1059. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  1060.  
  1061.  
  1062.  
  1063.           int ilDisplayIsCallbackEnabled(ilDisplay *obj)
  1064.  
  1065.  
  1066.  
  1067.  
  1068.           Returns _T_R_U_E if the post-render callback is enabled. Otherwise it
  1069.           rerutns _F_A_L_S_E. See sssseeeettttCCCCaaaallllllllbbbbaaaacccckkkk() and eeeennnnaaaabbbblllleeeeCCCCaaaallllllllbbbbaaaacccckkkk().
  1070.  
  1071.      iiiissssDDDDeeeeffffeeeerrrr(((())))
  1072.  
  1073.           int ilDisplayIsDefer(ilDisplay *obj, ilView* view)
  1074.  
  1075.  
  1076.           Returns the state of the defer flag for the specified view. If _v_i_e_w
  1077.           is NULL, the state of the defer flag on ilDisplay is returned.
  1078.           Returns TRUE if painting is deferred, FALSE otherwise.
  1079.  
  1080.      iiiissssDDDDoooouuuubbbblllleeeeBBBBuuuuffffffffeeeerrrr(((())))
  1081.  
  1082.           int ilDisplayIsDoubleBuffer(ilDisplay *obj)
  1083.  
  1084.  
  1085.           Returns TRUE if double buffer mode is set, FALSE otherwise.
  1086.  
  1087.      iiiissssFFFFrrrroooonnnnttttRRRReeeeddddrrrraaaawwwwEEEEnnnnaaaabbbblllleeeedddd(((())))
  1088.  
  1089.           int ilDisplayIsFrontRedrawEnabled(ilDisplay *obj)
  1090.  
  1091.  
  1092.           This member function returns _T_R_U_E if front redraw is enabled,
  1093.           otherwise it returns _F_A_L_S_E. See also iiiillllDDDDiiiissssppppllllaaaayyyyEEEEnnnnaaaabbbblllleeeeFFFFrrrroooonnnnttttRRRReeeeddddrrrraaaawwww().
  1094.  
  1095.      iiiissssNNNNoooopppp(((())))
  1096.  
  1097.           int ilDisplayIsNop(ilDisplay *obj, ilView* view)
  1098.  
  1099.  
  1100.           Returns TRUE if the nop flag is set on the specified view, FALSE
  1101.           otherwise.  If view is NULL, then the view on the top of the stack
  1102.           is tested.
  1103.  
  1104.      iiiissssQQQQuuuueeeeuuuueeeeiiiinnnnggggEEEEnnnnaaaabbbblllleeeedddd(((())))
  1105.  
  1106.           int ilDisplayIsQueueingEnabled(ilDisplay *obj)
  1107.  
  1108.  
  1109.           Returns TRUE if queued rendering is enabled, FALSE otherwise.  See
  1110.           eeeennnnaaaabbbblllleeeeQQQQuuuueeeeuuuueeeeiiiinnnngggg().
  1111.  
  1112.      iiiissssRRRRggggbbbb(((())))
  1113.  
  1114.  
  1115.  
  1116.  
  1117.  
  1118.                                                                        PPPPaaaaggggeeee 11117777
  1119.  
  1120.  
  1121.  
  1122.  
  1123.  
  1124.  
  1125. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  1126.  
  1127.  
  1128.  
  1129.           int ilDisplayIsRgb(ilDisplay *obj)
  1130.  
  1131.  
  1132.           Returns the GL color mode: TRUE for RGBmode, FALSE for colormap.
  1133.  
  1134.      iiiissssSSSSeeeelllleeeecccctttteeeedddd(((())))
  1135.  
  1136.           int ilDisplayIsSelected(ilDisplay *obj, ilView* view)
  1137.  
  1138.  
  1139.           Returns TRUE if the specified view is selected, FALSE otherwise.
  1140.           When an ilView is selected, its nop flag is FALSE and its borders
  1141.           are enabled.
  1142.  
  1143.      iiiissssSSSStttteeeerrrreeeeoooo(((())))
  1144.  
  1145.           int ilDisplayIsStereo(ilDisplay *obj)
  1146.  
  1147.  
  1148.           Returns TRUE if stereo viewing mode is available, FALSE otherwise.
  1149.           ilDisplay supports both monoscopic and stereoscopic views
  1150.           simultaneously within the same GL window. Stereo is only supported
  1151.           on InfiniteReality, RealityEngine and Impact graphics systems.
  1152.  
  1153.      mmmmaaaappppTTTTiiiilllleeee(((())))
  1154.  
  1155.           void ilDisplayMapTileFloat(ilDisplay *obj, iflOrientation fromOrientation,
  1156.                                      iflTile2Dfloat* tile, iflOrientation toOrientation(0))
  1157.           void ilDisplayMapTile(ilDisplay *obj, iflOrientation fromOrientation,
  1158.                                 iflTile2Dint* tile, iflOrientation toOrientation(0))
  1159.  
  1160.  
  1161.           Maps the specified _t_i_l_e from the _f_r_o_m_O_r_i_e_n_t_a_t_i_o_n to the
  1162.           _t_o_O_r_i_e_n_t_a_t_i_o_n relative to the ilXWindowImg used by ilDisplay. By
  1163.           default, the orientation of ilDisplay (upper-left) is used for
  1164.           _t_o_O_r_i_e_n_t_a_t_i_o_n.
  1165.  
  1166.      mmmmaaaappppXXXXYYYY(((())))
  1167.  
  1168.           void ilDisplayMapXYFloat(ilDisplay *obj, iflOrientation fromOrientation,
  1169.                                    float* x, float* y, iflOrientation toOrientation(0))
  1170.           void ilDisplayMapXY(ilDisplay *obj, iflOrientation fromOrientation,
  1171.                               int* x, int* y, iflOrientation toOrientation(0))
  1172.  
  1173.  
  1174.           Maps _i_x and _i_y from _f_r_o_m_O_r_i_e_n_t_a_t_i_o_n to _t_o_O_r_i_e_n_t_a_t_i_o_n and returns the
  1175.           result in _o_x and _o_y. By default, the orientation of ilDisplay
  1176.           (upper-left) is used for _t_o_O_r_i_e_n_t_a_t_i_o_n.
  1177.  
  1178.  
  1179.  
  1180.  
  1181.  
  1182.  
  1183.  
  1184.                                                                        PPPPaaaaggggeeee 11118888
  1185.  
  1186.  
  1187.  
  1188.  
  1189.  
  1190.  
  1191. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  1192.  
  1193.  
  1194.  
  1195.      mmmmoooovvvveeeeIIIImmmmgggg(((())))
  1196.  
  1197.           void ilDisplayMoveImg(ilDisplay *obj, float x, float y,
  1198.                                 ilView* view, int mode)
  1199.           void ilDisplayMoveImgIdx(ilDisplay *obj, float x, float y,
  1200.                                 ilView* view, int idx, int mode)
  1201.  
  1202.  
  1203.           These functions move the image within the specified _v_i_e_w. If NULL is
  1204.           passed as _v_i_e_w, then the images are moved in all views in the stack
  1205.           (except those with nop flag set). The image is moved as specified by
  1206.           _x and _y. The _m_o_d_e controls how the function operates. If ilClip is
  1207.           passed in mode, the image position is clipped to prevent moving
  1208.           beyond the edge of the image. However, by default, the image can be
  1209.           moved beyond its edge, exposing the image's fill value. The view is
  1210.           painted after the image has been moved, unless ilDefer is passed in
  1211.           mode.
  1212.  
  1213.           The mode also controls how the _x and _y parameters are interpreted.
  1214.           If ilDelVal is passed in _m_o_d_e, x and y specify the change (delta) in
  1215.           the image position. If ilAbsVal is specified, x and y specify the
  1216.           new position of the image. Note that the image position corresponds
  1217.           to the upper-left corner of the view, rather than the origin of the
  1218.           image.
  1219.  
  1220.           If ilRelVal is passed in _m_o_d_e, then x and y are interpreted relative
  1221.           to a starting xy coordinate maintained within ilDisplay.  Typically,
  1222.           ilRelVal is used for interactive applications that use the mouse to
  1223.           control movement. The sssseeeettttMMMMoooouuuusssseeee() function on ilDisplay must be
  1224.           called to set the starting xy location. Then the difference between
  1225.           the starting xy location and the specified xy location is used to
  1226.           adjust the image position. The starting xy location is then updated.
  1227.           Specifying ilOldRel has the same effect as ilRelVal except that the
  1228.           starting xy location is not updated.
  1229.  
  1230.           The portion of the image being displayed resides in the cache of the
  1231.           input image. So as the image is moved within the view, old pages are
  1232.           discarded and new pages are brought into the cache.
  1233.  
  1234.           Note that if a roam limit has been set with sssseeeettttRRRRooooaaaammmmLLLLiiiimmmmiiiitttt(), that
  1235.           image movement may be clipped. See setRoamLimit() for more
  1236.           information.
  1237.  
  1238.           For those views displaying multiple images (i.e., iiiillllSSSStttteeeerrrreeeeooooVVVViiiieeeewwww), the
  1239.           function allows independent movement of each image within the view.
  1240.           For stereo views, the valid values for _i_d_x are ilViewImgPairLeft and
  1241.           ilViewImgPairRight.
  1242.  
  1243.      mmmmoooovvvveeeeVVVViiiieeeewwww(((())))
  1244.  
  1245.  
  1246.  
  1247.  
  1248.  
  1249.  
  1250.                                                                        PPPPaaaaggggeeee 11119999
  1251.  
  1252.  
  1253.  
  1254.  
  1255.  
  1256.  
  1257. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  1258.  
  1259.  
  1260.  
  1261.           void ilDisplayMoveView(ilDisplay *obj, int x, int y, ilView* view,
  1262.                                  int mode)
  1263.  
  1264.  
  1265.           This function moves the specified view within the display. If NULL
  1266.           is passed, then the image is moved in all views in the stack (except
  1267.           those with nop flag set). The image is moved as specified by _x and
  1268.           _y. The _m_o_d_e controls how the function operates. If ilClip is passed
  1269.           in mode, the view position is clipped to prevent moving beyond the
  1270.           edge of the display. However, by default, the view can be moved
  1271.           beyond the edge of the display. The view is painted after the view
  1272.           has been moved, unless ilDefer is passed in mode. The mode also
  1273.           controls how the _x and _y parameters are interpreted.
  1274.  
  1275.           If ilDelVal is passed in _m_o_d_e, _x and _y specify the change (delta) in
  1276.           the view position. If ilAbsVal is specified, x and y specify the new
  1277.           position of the view. Note that the view position corresponds to the
  1278.           upper-left corner of the view relative to the upper-left corner of
  1279.           the display.
  1280.  
  1281.           If ilRelVal is passed in _m_o_d_e, then x and y are interpreted relative
  1282.           to a starting xy coordinate maintained within ilDisplay. Typically,
  1283.           ilRelVal is used for interactive applications that use the mouse to
  1284.           control movement. The sssseeeettttMMMMoooouuuusssseeee() function on ilDisplay must be
  1285.           called to set the starting _x_y location. Then the difference between
  1286.           the starting _x_y location and the specified _x_y location is used to
  1287.           adjust the view position. The starting _x_y location is then updated.
  1288.           Specifying ilOldRel has the same effect as ilRelVal except that the
  1289.           starting _x_y location is not updated.
  1290.  
  1291.      ppppaaaaiiiinnnntttt(((())))
  1292.  
  1293.           void ilDisplayPaint(ilDisplay *obj, ilView* view, int mode)
  1294.           void ilDisplayPaintArea(ilDisplay *obj, int x, int y,
  1295.                                   int nx, int ny, iflOrientation orientation,
  1296.                                   ilView* view, int mode)
  1297.  
  1298.  
  1299.           This function paints the specified view if it needs to be painted.
  1300.           If _N_U_L_L is passed, then all views are painted if needed (except
  1301.           those with nop flag set). If an area is specified with origin _x, _y
  1302.           and size _n_x, _n_y then only the specified area is painted. The area
  1303.           parameters are interpreted based on the _o_r_i_e_n_t_a_t_i_o_n specified.
  1304.  
  1305.           If iiiillllPPPPaaaaiiiinnnnttttEEEExxxxppppoooosssseeee is passed in _m_o_d_e, the view is forced to be
  1306.           painted. If iiiillllDDDDeeeeffffeeeerrrr is passed in _m_o_d_e, or if the view is deferred
  1307.           (see sssseeeettttDDDDeeeeffffeeeerrrr()), then the view is not be painted. The view
  1308.           position, size, and image position are unaffected.
  1309.  
  1310.      ppppoooopppp(((())))
  1311.  
  1312.  
  1313.  
  1314.  
  1315.  
  1316.                                                                        PPPPaaaaggggeeee 22220000
  1317.  
  1318.  
  1319.  
  1320.  
  1321.  
  1322.  
  1323. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  1324.  
  1325.  
  1326.  
  1327.           void ilDisplayPop(ilDisplay *obj, ilView* view, int count)
  1328.  
  1329.  
  1330.           Pops _v_i_e_w up _c_o_u_n_t positions in the stack. If _c_o_u_n_t is zero, the
  1331.           view is popped to the top of the stack. If _v_i_e_w is NULL, the bottom
  1332.           view is popped.
  1333.  
  1334.      ppppuuuusssshhhh(((())))
  1335.  
  1336.           void ilDisplayPush(ilDisplay *obj, ilView* view, int count)
  1337.  
  1338.  
  1339.           Pushes _v_i_e_w down _c_o_u_n_t positions in the stack. If _c_o_u_n_t is zero, the
  1340.           view is pushed to the bottom of the stack. If _v_i_e_w is NULL, the top
  1341.           view is pushed.
  1342.  
  1343.      qqqqPPPPaaaaiiiinnnntttt(((())))
  1344.  
  1345.           void ilDisplayQPaint(ilDisplay *obj, ilMpNode* parent,
  1346.                                ilView* view, int mode, ilMpManager** pMgr)
  1347.           void ilDisplayQPaintArea(ilDisplay *obj, ilMpNode* parent,
  1348.                                    int x, int y, int nx, int ny,
  1349.                                    iflOrientation orientation,
  1350.                                    ilView* view, int mode, ilMpManager** pMgr)
  1351.  
  1352.  
  1353.           This function is identical to iiiillllDDDDiiiissssppppllllaaaayyyyPPPPaaaaiiiinnnntttt() except that the paint
  1354.           operation is queued and the function returns immediately. This
  1355.           allows the application thread to return to processing events and
  1356.           thus provide a responsive UI. See iiiillllMMMMppppMMMMaaaannnnaaaaggggeeeerrrr and iiiillllMMMMppppNNNNooooddddeeee for more
  1357.           information.
  1358.  
  1359.           If an iiiillllMMMMppppNNNNooooddddeeee is passed as _p_a_r_e_n_t, the paint requests are queued on
  1360.           the parent node. If _p_M_g_r is specified, the iiiillllMMMMppppMMMMaaaannnnaaaaggggeeeerrrr created to
  1361.           queue the paint requests is returned. This allows an application to
  1362.           setup a completion callback or wait for the queued requests to
  1363.           complete.
  1364.  
  1365.      rrrreeeeddddrrrraaaawwww(((())))
  1366.  
  1367.           void ilDisplayRedraw(ilDisplay *obj, int mode)
  1368.           void ilDisplayRedrawArea(ilDisplay *obj, int x, int y,
  1369.                                    int nx, int ny, iflOrientation orientation,
  1370.                                    int mode)
  1371.  
  1372.  
  1373.           Resizes the display and back view to the size of the display window
  1374.           and repaints all views. If an area is specified with origin _x, _y and
  1375.           size _n_x, _n_y then only the specified area is painted.  If iiiillllDDDDeeeeffffeeeerrrr is
  1376.           passed in _m_o_d_e, the display and back view are resized but not
  1377.           painted and all views are unaffected.  This function is useful when
  1378.           an expose event occurs.
  1379.  
  1380.  
  1381.  
  1382.                                                                        PPPPaaaaggggeeee 22221111
  1383.  
  1384.  
  1385.  
  1386.  
  1387.  
  1388.  
  1389. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  1390.  
  1391.  
  1392.  
  1393.      rrrreeeemmmmoooovvvveeeeVVVViiiieeeewwwwCCCChhhhaaaannnnggggeeeeCCCCaaaallllllllbbbbaaaacccckkkk(((())))
  1394.  
  1395.           ilStatus ilDisplayRemoveViewChangeCallback(ilDisplay *obj,
  1396.                                                      ilCallback* cb)
  1397.  
  1398.  
  1399.           This method removes a view add/delete callback previously added with
  1400.           aaaaddddddddVVVViiiieeeewwwwCCCChhhhaaaannnnggggeeeeCCCCaaaallllllllbbbbaaaacccckkkk().
  1401.  
  1402.      ssssaaaavvvveeee(((())))
  1403.  
  1404.           ilStatus ilDisplaySave(ilDisplay *obj, ilImage* img, int x,
  1405.                                  int y, int mode)
  1406.  
  1407.  
  1408.           This function saves a region of the display area into the ilImage
  1409.           specified by _i_m_g. The region that is saved starts at the location
  1410.           specified by _x and _y and is the size of _i_m_g. By default, borders are
  1411.           not painted. However, if ilPaintBorder is passed in _m_o_d_e, then
  1412.           borders are painted on views with borders turned on.
  1413.  
  1414.      sssseeeelllleeeecccctttt(((())))
  1415.  
  1416.           void ilDisplaySelect(ilDisplay *obj, ilView* view)
  1417.  
  1418.  
  1419.           Selects the specified view. If NULL is passed, then all views in the
  1420.           view stack are selected. When a view is selected, its nop flag is
  1421.           FALSE and its borders are enabled.
  1422.  
  1423.      sssseeeettttBBBBaaaacccckkkkggggrrrroooouuuunnnndddd(((())))
  1424.  
  1425.           void ilDisplaySetBackground(ilDisplay *obj, float red,
  1426.                                       float green, float blue)
  1427.  
  1428.  
  1429.           Sets the ilDisplay's background color to that specified by _r_e_d,
  1430.           _g_r_e_e_n and _b_l_u_e. The values are assumed to be normalized to the range
  1431.           0.0 to 1.0.
  1432.  
  1433.      sssseeeettttBBBBaaaacccckkkkggggrrrroooouuuunnnnddddDDDDiiiirrrrttttyyyy(((())))
  1434.  
  1435.           void ilDisplayBackgroundSetDirty(ilDisplay *obj)
  1436.  
  1437.  
  1438.           Indicates that the ilDisplay's background needs to be repainted for
  1439.           some external reason (e.g. graphics drawn on top that need to be
  1440.           updated).
  1441.  
  1442.      sssseeeettttBBBBoooorrrrddddeeeerrrrCCCCoooolllloooorrrr(((())))
  1443.  
  1444.  
  1445.  
  1446.  
  1447.  
  1448.                                                                        PPPPaaaaggggeeee 22222222
  1449.  
  1450.  
  1451.  
  1452.  
  1453.  
  1454.  
  1455. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  1456.  
  1457.  
  1458.  
  1459.           void ilDisplaySetBorderColor(ilDisplay *obj, float red,
  1460.                                        float green, float blue)
  1461.  
  1462.  
  1463.           Sets the border color to _r_e_d, _g_r_e_e_n and _b_l_u_e on all views in the
  1464.           stack. The values are assumed to be normalized to the range 0.0 to
  1465.           1.0.  See also iiiillllVVVViiiieeeewwww.
  1466.  
  1467.      sssseeeettttBBBBoooorrrrddddeeeerrrrSSSSttttyyyylllleeee(((())))
  1468.  
  1469.           void ilDisplaySetBorderStyle(ilDisplay *obj, int style)
  1470.  
  1471.  
  1472.           Sets the border style on all views, to that specified by _s_t_y_l_e. By
  1473.           default, view borders are set to iiiillllVVVViiiieeeewwwwBBBBddddrrrrSSSSoooolllliiiiddddLLLLiiiinnnneeeessss.  See iiiillllVVVViiiieeeewwww
  1474.           for more information.
  1475.  
  1476.      sssseeeettttBBBBoooorrrrddddeeeerrrrWWWWiiiiddddtttthhhh(((())))
  1477.  
  1478.           void ilDisplaySetBorderWidth(ilDisplay *obj, int width)
  1479.  
  1480.  
  1481.           Sets the border width to _w_i_d_t_h on all views in the stack.
  1482.  
  1483.      sssseeeettttBBBBoooorrrrddddeeeerrrrssss(((())))
  1484.  
  1485.           void ilDisplaySetBorders(ilDisplay *obj, int enable, int mode)
  1486.  
  1487.  
  1488.           Sets the border flag on all views in the stack to the specified
  1489.           value.  If _f_l_a_g is TRUE, then borders are turned on, otherwise
  1490.           borders are turned off. Borders will be painted or erased unless
  1491.           defer mode has been set.
  1492.  
  1493.      sssseeeettttCCCCaaaallllllllbbbbaaaacccckkkk(((())))
  1494.  
  1495.           void ilDisplaySetCallback(ilDisplay *obj, ilCallback* prepare,
  1496.                                     ilCallback* render, ilCallback* finish)
  1497.  
  1498.  
  1499.           Sets the post-render callback which is associated with the back
  1500.           view.  The callback is called after all views have been rendered.
  1501.           There are actually three callbacks: _p_r_e_p_a_r_e, _r_e_n_d_e_r and _f_i_n_i_s_h.  The
  1502.           prepare callback is called by one of the compute threads to perform
  1503.           any pre-rendering allocations or computations. Then the render
  1504.           callback is called by the IL's render thread to perform actual
  1505.           rendering into the display window. This callback must execute as
  1506.           efficiently as possible to achieve maximum performance. It is called
  1507.           by the IL's render thread to minimize context switching. Any state
  1508.           changes made by the callback must be restored prior to completion.
  1509.           Finally, the finish callback is called by one of the compute threads
  1510.           to perform any de-allocation or cleanup required. The prepare and
  1511.  
  1512.  
  1513.  
  1514.                                                                        PPPPaaaaggggeeee 22223333
  1515.  
  1516.  
  1517.  
  1518.  
  1519.  
  1520.  
  1521. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  1522.  
  1523.  
  1524.  
  1525.           finish callbacks may be set to NULL if not required. See iiiillllVVVViiiieeeewwww and
  1526.           iiiillllVVVViiiieeeewwwwCCCCaaaallllllllbbbbaaaacccckkkk for more information.
  1527.  
  1528.      sssseeeettttCCCCoooolllloooorrrrmmmmaaaapppp(((())))
  1529.  
  1530.           void ilDisplaySetColormap(ilDisplay *obj, iflColormap* cmap)
  1531.  
  1532.  
  1533.           Sets the colormap to the ilLut specified by _c_m_a_p. The colormap is
  1534.           used by iiiillllXXXXDDDDiiiissssppppllllaaaayyyyIIIImmmmgggg or iiiillllGGGGLLLLDDDDiiiissssppppllllaaaayyyyIIIImmmmgggg depending on the render
  1535.           mode. Note that this will override the iiiillllDDDDeeeeffffaaaauuuullllttttCCCCmmmmaaaapppp mode passed to
  1536.           the constructor.
  1537.  
  1538.      sssseeeettttDDDDeeeeffffeeeerrrr(((())))
  1539.  
  1540.           void ilDisplaySetDefer(ilDisplay *obj, int def, ilView* view)
  1541.  
  1542.  
  1543.           Sets the state of the defer flag on the specified view. If _v_i_e_w is
  1544.           NULL, then the defer flag on ilDisplay is set. If _d_e_f_e_r is TRUE,
  1545.           then painting does not occur or is deferred. When painting is
  1546.           deferred, changes to a view's position, size or image position are
  1547.           accumulated until the view can be painted. Note that ilDisplay can
  1548.           be deferred or each individual ilView can be deferred.
  1549.  
  1550.      sssseeeettttLLLLoooocccc(((())))
  1551.  
  1552.           ilView* ilDisplaySetLoc(ilDisplay *obj, float ix, float iy,
  1553.                                   float x, float y, int mode)
  1554.  
  1555.  
  1556.           This function finds the view at xy and sets the location in the
  1557.           image specified by _i_x and _i_y to the location in the display
  1558.           specified by _x and _y. The image is moved as needed to relocate the
  1559.           specified point. If iiiillllLLLLooooccccIIIInnnn is passed in _m_o_d_e, the location is found
  1560.           in the input space of the image.  If iiiillllLLLLooooccccIIIInnnn is passed in _m_o_d_e, the
  1561.           location is found in the output space of the image.  For example, if
  1562.           an ilRotZoomIng is mapped to the view and ilLocIn is specified, _i_x
  1563.           and _i_y correspond to the location in the unrotated image. However,
  1564.           if ilLocOut is specified, _i_x and _i_y correspond to the location in
  1565.           the rotated image. The relocation can be accomplished by moving
  1566.           either the image or the view. If iiiillllLLLLooooccccVVVViiiieeeewwww is specified then the
  1567.           view is moved, alternatively if iiiillllLLLLooooccccIIIImmmmgggg is specified (default) then
  1568.           the image is moved.
  1569.  
  1570.      sssseeeettttMMMMaaaarrrrggggiiiinnnn(((())))
  1571.  
  1572.           void ilDisplaySetMargin(ilDisplay *obj, int margin)
  1573.  
  1574.  
  1575.  
  1576.  
  1577.  
  1578.  
  1579.  
  1580.                                                                        PPPPaaaaggggeeee 22224444
  1581.  
  1582.  
  1583.  
  1584.  
  1585.  
  1586.  
  1587. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  1588.  
  1589.  
  1590.  
  1591.           Sets the default margin to the number of pixels specified in _m_a_r_g_i_n.
  1592.           This margin is used by ffffiiiinnnnddddEEEEddddggggeeee() if no margin is specified.
  1593.  
  1594.      sssseeeettttMMMMooooddddeeee(((())))
  1595.  
  1596.           void ilDisplaySetMode(ilDisplay *obj, int mode)
  1597.  
  1598.  
  1599.           Sets the display mode as specified by _m_o_d_e. This display mode is
  1600.           added to the mode used to create new views with aaaaddddddddVVVViiiieeeewwww().  For
  1601.           example, if ilDefer is set in the display mode, then ilDefer will be
  1602.           added to the mode passed to addView().
  1603.  
  1604.      sssseeeettttMMMMoooouuuusssseeee(((())))
  1605.  
  1606.           void ilDisplaySetMouse(ilDisplay *obj, int x, int y, int mode)
  1607.  
  1608.  
  1609.           Sets the starting mouse location to the coordinate _x, _y.  Note that
  1610.           x and y are interpreted in the current event space, which is
  1611.           determined by the type of window (X or GL) being used.  This method
  1612.           is typically used to preset mouse values to initialize an
  1613.           interactive display operation loop such as moving a view.
  1614.  
  1615.      sssseeeettttNNNNoooopppp(((())))
  1616.  
  1617.           void ilDisplaySetNop(ilDisplay *obj, int noOp, ilView* view)
  1618.  
  1619.  
  1620.           Sets NOP state for the specified view. If view is NULL, then all
  1621.           views are set. If set to TRUE, display operations are disabled on
  1622.           this view until the flag is set to FALSE.
  1623.  
  1624.      sssseeeettttPPPPiiiixxxxeeeellll(((())))
  1625.  
  1626.           ilView* ilDisplaySetPixel(ilDisplay *obj, int x, int y,
  1627.                                     iflPixel* pix)
  1628.  
  1629.  
  1630.           Sets the pixel located _x and _y to the value specified in _p_i_x.  First
  1631.           the view at _x,_y is found using ffffiiiinnnnddddVVVViiiieeeewwww() and sssseeeettttPPPPiiiixxxxeeeellll() is called
  1632.           on that ilView. See the ilView man page for more information.
  1633.  
  1634.      sssseeeettttRRRRooooaaaammmmLLLLiiiimmmmiiiitttt(((())))
  1635.  
  1636.           void ilDisplaySetRoamLimit(ilDisplay *obj, float maxRoamDel.0)
  1637.  
  1638.  
  1639.           Sets the maximum number of pixels an image can move.  The roam limit
  1640.           causes image movement to be limited in order to facilitate smooth
  1641.           roaming with iiiillllDDDDiiiissssppppllllaaaayyyyMMMMoooovvvveeeeIIIImmmmgggg(). The roam limit is used to calculate
  1642.           the maximum roam rate in x and y for a given direction. If
  1643.  
  1644.  
  1645.  
  1646.                                                                        PPPPaaaaggggeeee 22225555
  1647.  
  1648.  
  1649.  
  1650.  
  1651.  
  1652.  
  1653. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  1654.  
  1655.  
  1656.  
  1657.           _m_a_x_R_o_a_m_D_e_l is set to 0.0 or negative, the roam limit is disabled.
  1658.  
  1659.      sssseeeettttSSSSttttaaaattttuuuussss(((())))
  1660.  
  1661.           void ilDisplaySetStatus(ilDisplay *obj, ilStatus stat)
  1662.  
  1663.  
  1664.           Sets the status of ilDisplay to the ilStatus specified in _s_t_a_t.  See
  1665.           also ggggeeeettttSSSSttttaaaattttuuuussss().
  1666.  
  1667.      sssseeeettttVVVViiiissssiiiibbbblllleeeeAAAArrrreeeeaaaa(((())))
  1668.  
  1669.           void ilDisplaySetVisibleArea(ilDisplay *obj, int x, int y,
  1670.                                        int nx, int ny)
  1671.  
  1672.  
  1673.           Sets the visible area within the display window in order to
  1674.           optimally support scrolled windows. The origin of the area is
  1675.           specified as _x, _y and the size of the area is specified by _n_x, _n_y.
  1676.           This causes painting to be clipped to the visual area.  If _0 is
  1677.           passed for all area parameters then this function is disabled.
  1678.  
  1679.      sssseeeettttWWWWiiiinnnnddddoooowwww(((())))
  1680.  
  1681.           void ilDisplaySetWindow(ilDisplay *obj, Window win, int mode)
  1682.  
  1683.  
  1684.           Sets the display window to the X window specified in _w_i_n and
  1685.           reinitializes ilDisplay. The render mode and display mode are
  1686.           specified as in the constructor. This function is used to change the
  1687.           configuration of the display window used by ilDisplay.
  1688.  
  1689.      sssspppplllliiiitttt(((())))
  1690.  
  1691.           void ilDisplaySplit(ilDisplay *obj, int mode)
  1692.  
  1693.  
  1694.           This function repositions and resizes all views in the view stack so
  1695.           that all views are visible. The _m_o_d_e specifies how the views are
  1696.           arranged. Starting at the bottom of the view stack, views are placed
  1697.           starting at the upper left corner of the display.  The various split
  1698.           modes are listed below:
  1699.  
  1700.           _i_l_A_b_s_S_p_l_i_t All images are aligned based on the align mode
  1701.                      specified (ilBottomLeft by default).
  1702.  
  1703.           _i_l_R_e_l_S_p_l_i_t All images are positioned relative to the view
  1704.                      position.
  1705.  
  1706.           _i_l_R_o_w_S_p_l_i_t The views are arranged in rows.
  1707.  
  1708.  
  1709.  
  1710.  
  1711.  
  1712.                                                                        PPPPaaaaggggeeee 22226666
  1713.  
  1714.  
  1715.  
  1716.  
  1717.  
  1718.  
  1719. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  1720.  
  1721.  
  1722.  
  1723.           _i_l_C_o_l_S_p_l_i_t The views are arranged in columns.
  1724.  
  1725.           _i_l_P_a_c_k_S_p_l_i_t Views sizes are clipped to the size of the image and
  1726.                      packed together.
  1727.  
  1728.           The relative split mode causes images to be positioned so that the
  1729.           image continues from one view to the next.  Any combination of these
  1730.           split modes can be used. For example, if
  1731.           ilRowSplit | ilColSplit is specified in _m_o_d_e, views are arranged
  1732.           into an equal number of rows and columns.
  1733.  
  1734.      sssswwwwaaaapppp(((())))
  1735.  
  1736.           void ilDisplaySwap(ilDisplay *obj, ilView* view1, ilView* view2)
  1737.  
  1738.  
  1739.           Swaps the positions in the view stack of the two views specified.
  1740.  
  1741.      ssssyyyynnnnccccPPPPaaaaiiiinnnntttt(((())))
  1742.  
  1743.           void ilDisplaySyncPaint(ilDisplay *obj)
  1744.  
  1745.  
  1746.           This method will not return until all queued rendering requests are
  1747.           completed.  See eeeennnnaaaabbbblllleeeeQQQQuuuueeeeuuuueeeeiiiinnnngggg().
  1748.  
  1749.      uuuunnnnsssseeeelllleeeecccctttt(((())))
  1750.  
  1751.           void ilDisplayUnselect(ilDisplay *obj, ilView* view)
  1752.  
  1753.  
  1754.           Unselects the specified view. If NULL is passed, then all views in
  1755.           the view stack are unselected (except those with nop flag set).
  1756.           When a view is unselected, its nop flag is TRUE and its borders are
  1757.           disabled.
  1758.  
  1759.      uuuuppppddddaaaatttteeee(((())))
  1760.  
  1761.           void ilDisplayUpdate(ilDisplay *obj, int x, int y, int nx,
  1762.                                int ny, float imgX, float imgY,
  1763.                                ilView* view, int mode)
  1764.  
  1765.  
  1766.           This function allows the view position, view size and image position
  1767.           to be adjusted for the specified view. If no view is specified, then
  1768.           all views are updated. The view is moved as specified by _x and _y.
  1769.           The view size is adjusted as specified by _n_x and _n_y. The image is
  1770.           moved within the view as specified by _i_m_g_X and _i_m_g_Y. All three
  1771.           adjustments are clipped if ilClip is passed in _m_o_d_e. After all three
  1772.           adjustments are made the view is painted, unless ilDefer is passed
  1773.           in _m_o_d_e.
  1774.  
  1775.  
  1776.  
  1777.  
  1778.                                                                        PPPPaaaaggggeeee 22227777
  1779.  
  1780.  
  1781.  
  1782.  
  1783.  
  1784.  
  1785. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  1786.  
  1787.  
  1788.  
  1789.           If ilDelVal is passed in _m_o_d_e, all parameters specify the change
  1790.           (delta) in position and size. If ilAbsVal is specified, all
  1791.           parameters specify the absolute position or size. If ilRelVal is
  1792.           passed in _m_o_d_e, then all parameters are interpreted relative to a
  1793.           starting xy coordinate maintained within ilDisplay. ilRelVal is not
  1794.           recommended for use with this operator. See ilDisplayMoveView and
  1795.           ilDisplayMoveImg for more details.
  1796.  
  1797.      uuuuppppddddaaaatttteeeeWWWWiiiinnnnddddoooowwww(((())))
  1798.  
  1799.           void ilDisplayUpdateWindow(ilDisplay *obj)
  1800.  
  1801.  
  1802.           This function is used to reinitialize the ilDisplay when the
  1803.           configuration of the display window has been changed. For example,
  1804.           if the GL window is changed from RGB mode to color index,
  1805.           uuuuppppddddaaaatttteeeeWWWWiiiinnnnddddoooowwww() must be called.
  1806.  
  1807.      wwwwiiiippppeeee(((())))
  1808.  
  1809.           void ilDisplayWipe(ilDisplay *obj, int x, int y, ilView* view,
  1810.                              int mode)
  1811.  
  1812.  
  1813.           This function moves one or more edges on the specified view. If NULL
  1814.           is passed, then all views are wiped (except those with nop flag
  1815.           set). The edge or edges to move are specified in _m_o_d_e. For example,
  1816.           if ilRightEdge is passed in mode, the right edge of the view moves
  1817.           as specified by _x and _y. In addition, if ilTopEdge | ilRightEdge (or
  1818.           ilTopRight) is specified, then the upper right corner is moved. Note
  1819.           that the value returned by ffffiiiinnnnddddEEEEddddggggeeee() can be used directly.
  1820.  
  1821.           In general, a wipe operation resizes the view. However, if ilAllEdge
  1822.           is passed in mode, then all edges of the view are moved and the view
  1823.           size is unchanged.  This operation is referred to as an _i_n_s_e_t - the
  1824.           image is stationary and the view moves. This is the opposite of
  1825.           moving the image within the view. When comparing images, wiping is
  1826.           very useful.
  1827.  
  1828.           If ilDelVal is passed in _m_o_d_e, _x and _y specify the change (delta) in
  1829.           the image position. If ilAbsVal is specified, _x and _y specify the
  1830.           new position of the image. If ilRelVal is passed in _m_o_d_e, then _x and
  1831.           _y are interpreted relative to a starting _x_y coordinate maintained
  1832.           within ilDisplay.
  1833.  
  1834.           If ilClip is passed in _m_o_d_e, the the edge is not allowed to move
  1835.           beyond the edge of the image. However, by default the edge can be
  1836.           moved beyond the edge of the image, exposing the image's fill value.
  1837.           If ilDefer is passed in _m_o_d_e, then the view is not painted after the
  1838.           operation.
  1839.  
  1840.  
  1841.  
  1842.  
  1843.  
  1844.                                                                        PPPPaaaaggggeeee 22228888
  1845.  
  1846.  
  1847.  
  1848.  
  1849.  
  1850.  
  1851. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  1852.  
  1853.  
  1854.  
  1855.      wwwwiiiippppeeeeSSSSiiiizzzzeeee(((())))
  1856.  
  1857.           void ilDisplayWipeSize(ilDisplay *obj, int x, int y, ilView* view,
  1858.                                  int mode)
  1859.  
  1860.  
  1861.           This function moves an edge or corner and the opposite edge or
  1862.           corner on the specified view. If NULL is passed, then all views in
  1863.           the view stack are affected (except those with nop flag set).  The
  1864.           edge or corner passed in _m_o_d_e is moved as specified by _x and _y. In
  1865.           addition, the opposite edge or corner is moved in the opposite
  1866.           direction. This causes the view to grow or shrink by moving opposite
  1867.           edges or corners. For example, if the right edge is moved right by
  1868.           ten pixels, the left edge is also moved left by ten pixels. Note
  1869.           that the value returned by ffffiiiinnnnddddEEEEddddggggeeee(((()))) can be used directly.
  1870.  
  1871.           If ilDelVal is passed in _m_o_d_e, _x and _y specify the change (delta) in
  1872.           the image position. If ilAbsVal is specified, _x and _y specify the
  1873.           new position of the image. If ilRelVal is passed in _m_o_d_e, then _x and
  1874.           _y are interpreted relative to a starting _x_y coordinate maintained
  1875.           within ilDisplay.
  1876.  
  1877.      wwwwiiiippppeeeeSSSSpppplllliiiitttt(((())))
  1878.  
  1879.           void ilDisplayWipeSplit(ilDisplay *obj, int x, int y,
  1880.                                   int mode)
  1881.  
  1882.  
  1883.           This function moves the edge on all views, found by calling
  1884.           ffffiiiinnnnddddEEEEddddggggeeee(((()))) on ilDisplay. All of these edges are moved as specified
  1885.           by _x and _y. For example, if two views are displayed side-by-side,
  1886.           the right edge of the left view and the left edge of the right view
  1887.           can be moved simultaneously. This is useful after a split operation.
  1888.  
  1889.           If ilDelVal is passed in _m_o_d_e, _x and _y specify the change (delta) in
  1890.           the image position. If ilAbsVal is specified, _x and _y specify the
  1891.           new position of the image. If ilRelVal is passed in _m_o_d_e, then _x and
  1892.           _y are interpreted relative to a starting _x_y coordinate maintained
  1893.           within ilDisplay.
  1894.  
  1895. SSSSEEEEEEEE AAAALLLLSSSSOOOO
  1896.      ilXWindowImg, ilView, ilViewIter, <il/ilDisplayDefs.h>
  1897.  
  1898.  
  1899. NNNNOOOOTTTTEEEESSSS
  1900.      Many display operators take a _m_o_d_e parameter which is a bit-wise
  1901.      inclusive OR of various flags defined in ilDisplayDefs.h. These flags are
  1902.      interpreted based on which operator is called. For example, iiiillllCCCCeeeennnntttteeeerrrr can
  1903.      be used to align a view or can be used to locate  the center of a view.
  1904.  
  1905.  
  1906.  
  1907.  
  1908.  
  1909.  
  1910.                                                                        PPPPaaaaggggeeee 22229999
  1911.  
  1912.  
  1913.  
  1914.  
  1915.  
  1916.  
  1917. iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))       IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiillllDDDDiiiissssppppllllaaaayyyy((((3333))))
  1918.  
  1919.  
  1920.  
  1921.      All views in the view stack are deleted when ilDisplay is deleted.
  1922.  
  1923.      ilViewIter can be used to iterate through the view stack. It is declared
  1924.      in _i_l_D_i_s_p_l_a_y._h
  1925.  
  1926.  
  1927.  
  1928.  
  1929.  
  1930.  
  1931.  
  1932.  
  1933.  
  1934.  
  1935.  
  1936.  
  1937.  
  1938.  
  1939.  
  1940.  
  1941.  
  1942.  
  1943.  
  1944.  
  1945.  
  1946.  
  1947.  
  1948.  
  1949.  
  1950.  
  1951.  
  1952.  
  1953.  
  1954.  
  1955.  
  1956.  
  1957.  
  1958.  
  1959.  
  1960.  
  1961.  
  1962.  
  1963.  
  1964.  
  1965.  
  1966.  
  1967.  
  1968.  
  1969.  
  1970.  
  1971.  
  1972.  
  1973.  
  1974.  
  1975.  
  1976.                                                                        PPPPaaaaggggeeee 33330000
  1977.  
  1978.  
  1979.  
  1980.